home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / xwindows / demos / xfract_1.z / xfract_1 / xfractint-1.06 / mpmath.h < prev    next >
C/C++ Source or Header  |  1992-09-28  |  7KB  |  216 lines
  1. /*
  2.  *  REMOVED FORMAL PARAMETERS FROM FUNCTION DEFINITIONS (1/4/92)
  3.  */
  4.  
  5.  
  6. #ifndef MPMATH_H
  7. #define MPMATH_H
  8.  
  9. #include <math.h>
  10.  
  11. #ifdef XFRACT
  12. #ifndef _LCOMPLEX_DEFINED
  13. struct lcomplex {
  14.    long x, y;
  15. };
  16. struct complex {
  17.     double x,y;
  18. };
  19. #define _LCOMPLEX_DEFINED
  20. #endif
  21. #define far
  22. #endif
  23.  
  24. struct HyperComplex {
  25.     double x,y,z,w;
  26. };
  27.  
  28. struct LHyperComplex {
  29.     long x,y,z,w;
  30. };
  31.  
  32. #ifndef XFRACT
  33. struct MP {
  34.    int Exp;
  35.         unsigned long Mant;
  36. };
  37. #else
  38. struct MP {
  39.    double val;
  40. };
  41. #endif
  42.  
  43. struct MPC {
  44.         struct MP x, y;
  45. };
  46.  
  47. extern struct MP MPTrigTable[2][4][256], InvHalfPi, HalfPi, InvLn2, Ln2;
  48. extern int MPaccuracy, MPOverflow;
  49. extern int DivideOverflow;
  50.  
  51. /* Mark Peterson's expanded floating point operators.  Automatically uses
  52.    either the 8086 or 80386 processor type specified in global 'cpu'. If
  53.    the operation results in an overflow (result < 2**(2**14), or division
  54.    by zero) the global 'MPoverflow' is set to one. */
  55.  
  56. extern int cpu;
  57.  
  58. /* function pointer support added by Tim Wegner 12/07/89 */
  59. extern int         (*pMPcmp)(struct MP , struct MP );
  60. extern struct MP  *(*pMPmul)(struct MP , struct MP );
  61. extern struct MP  *(*pMPdiv)(struct MP , struct MP );
  62. extern struct MP  *(*pMPadd)(struct MP , struct MP );
  63. extern struct MP  *(*pMPsub)(struct MP , struct MP );
  64. extern struct MP  *(*pd2MP)(double )                ;
  65. extern double     *(*pMP2d)(struct MP )             ;
  66.  
  67.  
  68. /*** Formula Declarations ***/
  69. typedef enum { D_MATH, M_MATH, L_MATH } MATH_TYPE;
  70. extern MATH_TYPE MathType;
  71.  
  72. #define fDiv(x, y, z) (void)((*(long*)&z) = RegDivFloat(*(long*)&x, *(long*)&y))
  73. #define fMul16(x, y, z) (void)((*(long*)&z) = r16Mul(*(long*)&x, *(long*)&y))
  74. #define fShift(x, Shift, z) (void)((*(long*)&z) = \
  75.    RegSftFloat(*(long*)&x, Shift))
  76. #define Fg2Float(x, f, z) (void)((*(long*)&z) = RegFg2Float(x, f))
  77. #define Float2Fg(x, f) RegFloat2Fg(*(long*)&x, f)
  78. #define fLog14(x, z) (void)((*(long*)&z) = \
  79.         RegFg2Float(LogFloat14(*(long*)&x), 16))
  80. #define fExp14(x, z) (void)((*(long*)&z) = ExpFloat14(*(long*)&x));
  81. #define fSqrt14(x, z) fLog14(x, z); fShift(z, -1, z); fExp14(z, z)
  82.  
  83. #ifndef _LCOMPLEX_DEFINED
  84. struct lcomplex {
  85.    long x, y;
  86. };
  87. #define _LCOMPLEX_DEFINED
  88. #endif
  89.  
  90. union Arg {
  91.    struct complex d;
  92.    struct MPC m;
  93.    struct lcomplex l;
  94. #ifndef XFRACT
  95.   // struct HyperComplex h;
  96.  // struct LHyperComplex lh;
  97. #endif
  98. };
  99.  
  100. extern union Arg *Arg1,*Arg2;
  101.  
  102. extern void lStkSin(),lStkCos(),lStkSinh(),lStkCosh(),lStkLog(),lStkExp(),lStkSqr();
  103. extern void dStkSin(),dStkCos(),dStkSinh(),dStkCosh(),dStkLog(),dStkExp(),dStkSqr();
  104.  
  105. extern void (*ltrig0)();
  106. extern void (*ltrig1)();
  107. extern void (*ltrig2)();
  108. extern void (*ltrig3)();
  109. extern void (*dtrig0)();
  110. extern void (*dtrig1)();
  111. extern void (*dtrig2)();
  112. extern void (*dtrig3)();
  113.  
  114. /* -------------------------------------------------------------------- */
  115. /*   The following #defines allow the complex transcendental functions    */
  116. /*   in parser.c to be used here thus avoiding duplicated code.     */
  117. /* -------------------------------------------------------------------- */
  118. #ifndef XFRACT
  119.  
  120. #define CMPLXmod(z)      (sqr((z).x)+sqr((z).y))
  121. #define CMPLXconj(z)    ((z).y =  -((z).y))
  122. #define LCMPLXmod(z)       (lsqr((z).x)+lsqr((z).y))
  123. #define LCMPLXconj(z)    ((z).y =  -((z).y))
  124.  
  125.  
  126. #define LCMPLXtrig0(arg,out) Arg1->l = (arg); ltrig0(); (out)=Arg1->l
  127. #define LCMPLXtrig1(arg,out) Arg1->l = (arg); ltrig1(); (out)=Arg1->l
  128. #define LCMPLXtrig2(arg,out) Arg1->l = (arg); ltrig2(); (out)=Arg1->l
  129. #define LCMPLXtrig3(arg,out) Arg1->l = (arg); ltrig3(); (out)=Arg1->l
  130.  
  131. #endif /* XFRACT */
  132.  
  133. #define  CMPLXtrig0(arg,out) Arg1->d = (arg); dtrig0(); (out)=Arg1->d
  134. #define  CMPLXtrig1(arg,out) Arg1->d = (arg); dtrig1(); (out)=Arg1->d
  135. #define  CMPLXtrig2(arg,out) Arg1->d = (arg); dtrig2(); (out)=Arg1->d
  136. #define  CMPLXtrig3(arg,out) Arg1->d = (arg); dtrig3(); (out)=Arg1->d
  137.  
  138. #ifndef XFRACT
  139.  
  140. #define LCMPLXsin(arg,out)   Arg1->l = (arg); lStkSin();  (out) = Arg1->l
  141. #define LCMPLXcos(arg,out)   Arg1->l = (arg); lStkCos();  (out) = Arg1->l
  142. #define LCMPLXsinh(arg,out)  Arg1->l = (arg); lStkSinh(); (out) = Arg1->l
  143. #define LCMPLXcosh(arg,out)  Arg1->l = (arg); lStkCosh(); (out) = Arg1->l
  144. #define LCMPLXlog(arg,out)   Arg1->l = (arg); lStkLog();  (out) = Arg1->l
  145. #define LCMPLXexp(arg,out)   Arg1->l = (arg); lStkExp();  (out) = Arg1->l
  146. /*
  147. #define LCMPLXsqr(arg,out)   Arg1->l = (arg); lStkSqr();  (out) = Arg1->l
  148. */
  149. #define LCMPLXsqr(arg,out)   \
  150.    (out).x = lsqr((arg).x) - lsqr((arg).y);\
  151.    (out).y = multiply((arg).x, (arg).y, bitshiftless1)
  152. #define LCMPLXsqr_old(out)     \
  153.    (out).y = multiply(lold.x, lold.y, bitshiftless1);\
  154.    (out).x = ltempsqrx - ltempsqry\
  155.  
  156. #define LCMPLXpwr(arg1,arg2,out)    Arg2->l = (arg1); Arg1->l = (arg2);\
  157.      lStkPwr(); Arg1++; Arg2++; (out) = Arg2->l
  158. #define LCMPLXmult(arg1,arg2,out)    Arg2->l = (arg1); Arg1->l = (arg2);\
  159.      lStkMul(); Arg1++; Arg2++; (out) = Arg2->l
  160. #define LCMPLXadd(arg1,arg2,out)    \
  161.     (out).x = (arg1).x + (arg2).x; (out).y = (arg1).y + (arg2).y
  162. #define LCMPLXsub(arg1,arg2,out)    \
  163.     (out).x = (arg1).x - (arg2).x; (out).y = (arg1).y - (arg2).y
  164.  
  165. #define LCMPLXtimesreal(arg,real,out)    \
  166.     (out).x = multiply((arg).x,(real),bitshift);\
  167.     (out).y = multiply((arg).y,(real),bitshift)
  168.  
  169. #define LCMPLXrecip(arg,out)    \
  170. { long denom; denom = lsqr((arg).x) + lsqr((arg).y);\
  171. if(denom==0L) overflow=1; else {(out).x = divide((arg).x,denom,bitshift);\
  172. (out).y = -divide((arg).y,denom,bitshift);}}
  173. #endif /* XFRACT */
  174.  
  175. #define CMPLXsin(arg,out)    Arg1->d = (arg); dStkSin();  (out) = Arg1->d
  176. #define CMPLXcos(arg,out)    Arg1->d = (arg); dStkCos();  (out) = Arg1->d
  177. #define CMPLXsinh(arg,out)   Arg1->d = (arg); dStkSinh(); (out) = Arg1->d
  178. #define CMPLXcosh(arg,out)   Arg1->d = (arg); dStkCosh(); (out) = Arg1->d
  179. #define CMPLXlog(arg,out)    Arg1->d = (arg); dStkLog();  (out) = Arg1->d
  180. #define CMPLXexp(arg,out)    FPUcplxexp(&(arg), &(out))
  181. /*
  182. #define CMPLXsqr(arg,out)    Arg1->d = (arg); dStkSqr();  (out) = Arg1->d
  183. */
  184. #define CMPLXsqr(arg,out)    \
  185.    (out).x = sqr((arg).x) - sqr((arg).y);\
  186.    (out).y = ((arg).x+(arg).x) * (arg).y
  187. #define CMPLXsqr_old(out)    \
  188.    (out).y = (old.x+old.x) * old.y;\
  189.    (out).x = tempsqrx - tempsqry
  190.  
  191. #define CMPLXpwr(arg1,arg2,out)   (out)= ComplexPower((arg1), (arg2))
  192. #define CMPLXmult1(arg1,arg2,out)    Arg2->d = (arg1); Arg1->d = (arg2);\
  193.      dStkMul(); Arg1++; Arg2++; (out) = Arg2->d
  194. #define CMPLXmult(arg1,arg2,out)  \
  195.     {\
  196.        CMPLX TmP;\
  197.        TmP.x = (arg1).x*(arg2).x - (arg1).y*(arg2).y;\
  198.        TmP.y = (arg1).x*(arg2).y + (arg1).y*(arg2).x;\
  199.        (out) = TmP;\
  200.      }
  201. #define CMPLXadd(arg1,arg2,out)    \
  202.     (out).x = (arg1).x + (arg2).x; (out).y = (arg1).y + (arg2).y
  203. #define CMPLXsub(arg1,arg2,out)    \
  204.     (out).x = (arg1).x - (arg2).x; (out).y = (arg1).y - (arg2).y
  205. #define CMPLXtimesreal(arg,real,out)   \
  206.     (out).x = (arg).x*(real);\
  207.     (out).y = (arg).y*(real)
  208.  
  209. #define CMPLXrecip(arg,out)    \
  210.    { double denom; denom = sqr((arg).x) + sqr((arg).y);\
  211.      if(denom==0.0) {(out).x = 1.0e10;(out).y = 1.0e10;}else\
  212.     { (out).x =  (arg).x/denom;\
  213.      (out).y = -(arg).y/denom;}}
  214.  
  215. #endif
  216.